package com.zhijian.medical.enums.diagnose.report;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 新辅后乳腺癌枚举
 */
@Slf4j
public class AdjuvantBreastEnum {

    /**
     * 标本名称
     */
    @AllArgsConstructor
    @Getter
    public enum SampleNameEnum {
        // 胃组织、吻合口近端、吻合口远端
        GASTROINTESTINAL("rightGastrointestinal", "胃组织"),
        ANASTOMOTIC_NEAR_END("anastomoticNearEnd", "吻合口近端"),
        ANASTOMOTIC_FAR_END("anastomoticFarEnd", "吻合口远端");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(SampleNameEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 标本类型
     */
    @AllArgsConstructor
    @Getter
    public enum SampleTypeEnum {
        // (改良)根治标本、(改良)根治标本，乳腺肿块切除后、单纯切除标本、保乳标本
        MODIFIED_ROOT("modifiedRoot", "(改良)根治标本"),
        MODIFIED_ROOT_AFTER_BREAST_TUMOR_REMOVAL("modifiedRootAfterBreastTumorRemoval", "(改良)根治标本，乳腺肿块切除后"),
        PURELY_CUTTING("purelyCutting", "单纯切除标本"),
        BREAST_CONSERVING("breastConserving", "保乳标本");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(SampleTypeEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 标本部位
     */
    @AllArgsConstructor
    @Getter
    public enum SamplePartEnum {
        // 左乳、右乳
        LEFT_BREAST("leftBreast", "左乳"),
        RIGHT_BREAST("rightBreast", "右乳");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(SamplePartEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 新辅助治疗方式
     */
    @AllArgsConstructor
    @Getter
    public enum NeoauxiliaryTreatmentEnum {
        // 新辅助化疗、新辅助靶向(抗KER2)联合化疗、新辅助内分泌治疗
        CHEMOTHERAPY("chemotherapy", "新辅助化疗"),
        TARGET_CHEMOTHERAPY("targetChemotherapy", "新辅助靶向(抗KER2)联合化疗"),
        ENDOCRINE_TREATMENT("endocrineTreatment", "新辅助内分泌治疗");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(NeoauxiliaryTreatmentEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 病灶位置
     */
    @AllArgsConstructor
    @Getter
    public enum LesionPositionEnum {
        // 内上象限、内下象限、外上象限、外下象限、中央、其他、无法评估
        INNER_UPPER("innerUpper", "内上象限"),
        INNER_LOWER("innerLower", "内下象限"),
        OUTER_UPPER("outerUpper", "外上象限"),
        OUTER_LOWER("outerLower", "外下象限"),
        CENTER("center", "中央"),
        OTHER("other", "其他"),
        UNABLE_TO_EVALUATE("unableToEvaluate", "无法评估");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(LesionPositionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e
                        .getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 病灶大小
     */
    @AllArgsConstructor
    @Getter
    public enum LesionSizeEnum {
        // 3.5x2.5、20x16x3
        SIZE_35x25("size35x25", "3.5x2.5"),
        SIZE_20x16x3("size20x16x3", "20x16x3");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(LesionSizeEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return
                    TEMP_MAPPING;
        }
    }

    /**
     * 浸润性病灶数量
     */
    @AllArgsConstructor
    @Getter
    public enum InvasiveLesionCountEnum {
        // 单个浸润癌灶、多个浸润癌灶、未见
        SINGLE("single", "单个浸润癌灶"),
        MULTIPLE("multiple", "多个浸润癌灶"),
        NOT_FOUND("not_found", "未见");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(InvasiveLesionCountEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 组织学类型(WHO)
     */
    @AllArgsConstructor
    @Getter
    public enum HistologicalTypeEnum {
        // 主要 化生性癌 乳头状肿瘤 非浸润住少叶性胂瘤
        MAIN("main", "主要", HistologicalTypeMainEnum.getList()),
        ADENOCARCINOMA("adenocarcinoma", "化生性癌", MetaplasticCarcinomaEnum.getList()),
        PAPILLOMA("papilloma", "乳头状肿瘤", PapillaryTumorEnum.getList()),
        NON_INVASIVE_LIQUID_BREAST_TUMOR("nonInvasiveLiquidBreastTumor", "非浸润性小叶性肿瘤", NonInvasiveLobularTumorEnum.getList());


        private final String key;
        private final String desc;
        private final List<MappingEnum<String, String>> child;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(HistologicalTypeEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), e.getChild()))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 组织学类型(WHO)-主要
     */
    @AllArgsConstructor
    @Getter
    public enum HistologicalTypeMainEnum {
        //乳腺浸润性癌，非特殊类型  伴有髓样特征的浸润性乳腺癌，非特殊类型  微浸润性癌  浸润性小叶癌，经典型  浸润性小叶癌，实性型  浸润性小叶癌，多形性  浸润性小叶癌，混合型  小管癌  筛状癌  粘液癌A型  粘液癌B型  粘液癌  伴有癌的腺肌上皮瘤  腺肌上皮癌  伴大汗腺分化的癌  浸润性微乳头状癌  混合性癌

        LOW_GRADE("lowGrade", "乳腺浸润性癌，非特殊类型"),
        FIBROUS_TUMOR("fibrousTumor", "伴有髓样特征的浸润性乳腺癌，非特殊类型"),
        SCALENOID_CARCINOMA("scalenoidCarcinoma", "微浸润性癌"),
        INVASIVE_LIQUID_BREAST_TUMOR("invasiveLiquidBreastTumor", "浸润性小叶癌，经典型"),
        SOLID_LIQUID_BREAST_TUMOR("solidLiquidBreastTumor", "浸润性小叶癌，实性型"),
        POLYPOID_LIQUID_BREAST_TUMOR("polypoidLiquidBreastTumor", "浸润性小叶癌，多形性"),
        MIXED_LIQUID_BREAST_TUMOR("mixedLiquidBreastTumor", "浸润性小叶癌，混合型"),
        SMALL_CELL_LIQUID_BREAST_TUMOR("smallCellLiquidBreastTumor", "小管癌"),
        SCARCE_CELL_LIQUID_BREAST_TUMOR("scarceCellLiquidBreastTumor", "筛状癌"),
        MUCINOUS_CARCINOMA_A("mucinousCarcinomaA", "粘液癌A型"),
        MUCINOUS_CARCINOMA_B("mucinousCarcinomaB", "粘液癌B型"),
        MUCINOUS_CARCINOMA("mucinousCarcinoma", "粘液癌"),
        ADENOSQUAMOUS_CARCINOMA("adenosquamousCarcinoma", "伴有癌的腺肌上皮瘤"),
        ADENOSQUAMOUS_CARCINOMA_WITH_HYPERPLASIA("adenosquamousCarcinomaWithHyperplasia", "腺肌上皮癌"),
        HYPERSECRETION("hypersecretion", "伴大汗腺分化的癌"),
        MICROPODIUM_CARCINOMA("micropodiumCarcinoma", "浸润性微乳头状癌"),
        MIXED("mixed", "混合性癌");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(HistologicalTypeMainEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 组织学类型(WHO)-化生性癌
     */
    @AllArgsConstructor
    @Getter
    public enum MetaplasticCarcinomaEnum {
        // 低级别腺鳞癌、纤维瘤病样化生性癌、鳞形细胞癌、梭形细胞癌、伴异源性间叶分化的化生性癌、混合性化生性癌
        LOW_GRADE("lowGrade", "低级别腺鳞癌"),
        FIBROUS_TUMOR("fibrousTumor", "纤维瘤病样化生性癌"),
        SCALENOID_CARCINOMA("scalenoidCarcinoma", "鳞形细胞癌"),
        SPINDLE_CELL_CARCINOMA("spindleCellCarcinoma", "梭形细胞癌"),
        HETEROGENIC_MESENCHYMAL_DIFFERENTIATION("heterogenicMesenchymalDifferentiation", "伴异源性间叶分化的化生性癌"),
        MIXED_TYPE("mixedType", "混合性化生性癌");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(MetaplasticCarcinomaEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 组织学类型(WHO)-乳头状肿瘤
     */
    @AllArgsConstructor
    @Getter
    public enum PapillaryTumorEnum {
        // 导管内乳头状瘤、导管内乳头状瘤伴非典型导管上皮增生、导管内乳头状瘤伴导管原位癌、乳头状导管原位癌、浸润性乳头状癌、包裹性乳头状癌、包裹性乳头状癌伴浸润、原位实性乳头状癌、实性乳头状癌伴浸润
        INTRADUCTAL_PAPILLARY_TUMOR("intraductalPapillaryTumor", "导管内乳头状瘤"),
        ATYPICAL_DUCTAL_HYPERPLASIA("atypicalDuctalHyperplasia", "导管内乳头状瘤伴非典型导管上皮增生"),
        WITH_DUCTAL_CARCINOMA_IN_SITU("withDuctalCarcinomaInSitu", "导管内乳头状瘤伴导管原位癌"),
        DUCTAL_CARCINOMA_IN_SITU("ductalCarcinomaInSitu", "乳头状导管原位癌"),
        INVASIVE_PAPILLARY_CARCINOMA("invasivePapillaryCarcinoma", "浸润性乳头状癌"),
        ENCAPSULATED_PAPILLARY_CARCINOMA("encapsulatedPapillaryCarcinoma", "包裹性乳头状癌"),
        ENCAPSULATED_PAPILLARY_CARCINOMA_WITH_INVASIVE("encapsulatedPapillaryCarcinomaWithInvasive", "包裹性乳头状癌伴浸润"),
        SOLID_PAPILLARY_CARCINOMA_IN_SITU("solidPapillaryCarcinomaInSitu", "原位实性乳头状癌"),
        SOLID_PAPILLARY_CARCINOMA("solidPapillaryCarcinoma", "实性乳头状癌伴浸润");


        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(PapillaryTumorEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 组织学类型(WHO)-非浸润性小叶性肿瘤
     */
    @AllArgsConstructor
    @Getter
    public enum NonInvasiveLobularTumorEnum {
        // 非典型小叶增生、小叶原位癌NOS、经典型小叶原位癌、旺炽型小叶原位癌、多形性小叶原位癌
        ATYPICAL_LOBULAR_HYPERPLASIA("atypicalLobularHyperplasia", "非典型小叶增生"),
        LOBULAR_CARCINOMA_IN_SITU_NOS("lobularCarcinomaInSituNos", "小叶原位癌NOS"),
        CLASSIC_LOBULAR_CARCINOMA_IN_SITU("classicLobularCarcinomaInSitu", "经典型小叶原位癌"),
        VIGOROUS_LOBULAR_CARCINOMA_IN_SITU("vigorousLobularCarcinomaInSitu", "旺炽型小叶原位癌"),
        POLYMORPHIC_LOBULAR_CARCINOMA_IN_SITU("polymorphicLobularCarcinomaInSitu", "多形性小叶原位癌");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(NonInvasiveLobularTumorEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 百分比
     */
    @AllArgsConstructor
    @Getter
    public enum PercentageEnum {

        P0(0, "0"),
        P10(10, "10"),
        P20(20, "20"),
        P30(30, "30"),
        P40(40, "40"),
        P50(50, "50"),
        P60(60, "60"),
        P70(70, "70"),
        P80(80, "80"),
        P90(90, "90"),
        P100(100, "100");

        private final Integer key;
        private final String desc;

        private static final List<MappingEnum<Integer, String>> TEMP_MAPPING = Arrays.stream(PercentageEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<Integer, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 腺管形成
     */
    @AllArgsConstructor
    @Getter
    public enum DuctalFormationEnum {
        //1 2 3
        DUCTAL_FORMATION_1("ductal_formation_1", "1"),
        DUCTAL_FORMATION_2("ductal_formation_2", "2"),
        DUCTAL_FORMATION_3("ductal_formation_3", "3");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(DuctalFormationEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }


    /**
     * 核多形性
     */
    @AllArgsConstructor
    @Getter
    public enum NucleiMultiformityEnum {
        //1 2 3
        NUCLEI_MULTIFORMITY_1("nuclei_multiformity_1", "1"),
        NUCLEI_MULTIFORMITY_2("nuclei_multiformity_2", "2"),
        NUCLEI_MULTIFORMITY_3("nuclei_multiformity_3", "3");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(NucleiMultiformityEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 核分裂计数
     */
    @AllArgsConstructor
    @Getter
    public enum NucleiMitosisCountEnum {
        //1 2 3
        NUCLEI_MITOSIS_COUNT_1("nuclei_mitosis_count_1", "1"),
        NUCLEI_MITOSIS_COUNT_2("nuclei_mitosis_count_2", "2"),
        NUCLEI_MITOSIS_COUNT_3("nuclei_mitosis_count_3", "3");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(NucleiMitosisCountEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 组织学类型-等级
     */
    @AllArgsConstructor
    @Getter
    public enum HistologicalTypeGradeEnum {
        //I级 II级 III级
        GRADE_I("grade_i", "I级"),
        GRADE_II("grade_ii", "II级"),
        GRADE_III("grade_iii", "III级");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(HistologicalTypeGradeEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 原位癌
     */
    @AllArgsConstructor
    @Getter
    public enum InSituCancerEnum {
        //导管原位癌 小叶原位癌，经典型 小叶原位癌，旺炽性 小叶原位癌，多形性 Paget's病 未见 其他
        DUCTAL_CARCINOMA_IN_SITU("ductal_carcinoma_in_situ", "导管原位癌"),
        LIQUID_BREAST_TUMOR_IN_SITU_CLASSICAL("liquid_breast_tumor_in_situ_classical", "小叶原位癌，经典型"),
        LIQUID_BREAST_TUMOR_IN_SITU_PROLIFERATIVE("liquid_breast_tumor_in_situ_proliferative", "小叶原位癌，旺炽性"),
        LIQUID_BREAST_TUMOR_IN_SITU_POLYPOID("liquid_breast_tumor_in_situ_polyoid", "小叶原位癌，多形性"),
        NOT_FOUND("not_found", "未见"),
        OTHER("other", "其他"),
        PAGET("paget", "Paget's病");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(InSituCancerEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 原位癌-百分比
     */
    @AllArgsConstructor
    @Getter
    public enum InSituCancerPercentageEnum {
        //0 1 5 10 20 30 40 50 60 70 80 90 100
        P0("p0", "0"),
        P1("p1", "1"),
        P5("p5", "5"),
        P10("p10", "10"),
        P20("p20", "20"),
        P30("p30", "30"),
        P40("p40", "40"),
        P50("p50", "50"),
        P60("p60", "60"),
        P70("p70", "70"),
        P80("p80", "80"),
        P90("p90", "90"),
        P100("p100", "100");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(InSituCancerPercentageEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 核级
     */
    @AllArgsConstructor
    @Getter
    public enum NucleiGradeEnum {
        //高 中 低
        HIGH("high", "高"),
        MIDDLE("middle", "中"),
        LOW("low", "低");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(NucleiGradeEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 坏死
     */
    @AllArgsConstructor
    @Getter
    public enum NecrosisEnum {
        //未见 点状坏死 粉刺样坏死
        NOT_FOUND("not_found", "未见"),
        POINT("point", "点状坏死"),
        PUSTULE("pustule", "粉刺样坏死");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(NecrosisEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 钙化
     */
    @AllArgsConstructor
    @Getter
    public enum CalcificationEnum {
        //可见 未见
        VISIBLE("visible", "可见"),
        NOT_FOUND("not_found", "未见");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(CalcificationEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 肿瘤间质浸润淋巴细胞sTILs
     */
    @AllArgsConstructor
    @Getter
    public enum TILsEnum {
        //0 1% 5% 10% 20% 30% 40% 50% 60% 70% 80% 90% 100% 无法评估
        P0("p0", "0"),
        P1("p1", "1%"),
        P5("p5", "5%"),
        P10("p10", "10%"),
        P20("p20", "20%"),
        P30("p30", "30%"),
        P40("p40", "40%"),
        P50("p50", "50%"),
        P60("p60", "60%"),
        P70("p70", "70%"),
        P80("p80", "80%"),
        P90("p90", "90%"),
        P100("p100", "100%"),
        UNABLE_TO_EVALUATE("unable_to_evaluate", "无法评估");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(TILsEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 脉管癌栓
     */
    @AllArgsConstructor
    @Getter
    public enum VascularCancerThrombusEnum {

        NOT_YET_SEEN("not_yet_seen", "末见癌栓"),
        VISIBLE("visible", "见癌栓"),
        SUSPICIOUS("suspicious", "可疑"),
        UNABLE_TO_EVALUATE("unable_to_evaluate", "无法评估");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(VascularCancerThrombusEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 神经侵犯
     */
    @AllArgsConstructor
    @Getter
    public enum NeurologicalInvasionEnum {

        NOT_YET_SEEN("not_yet_seen", "未见侵犯"),
        VISIBLE("visible", "见侵犯"),
        SUSPICIOUS("suspicious", "可疑"),
        UNABLE_TO_EVALUATE("unable_to_evaluate", "无法评估");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(NeurologicalInvasionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 乳头侵犯
     */
    @AllArgsConstructor
    @Getter
    public enum NippleInvasionEnum {
        //(-) (+) (/) 未送检
        NOT_SEEN("not_seen", "(-)"),
        SEEN("seen", "(+)"),
        UNABLE_TO_EVALUATE("unable_to_evaluate", "(/)"),
        NOT_SENT("not_sent", "未送检");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(NippleInvasionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 皮肤侵犯
     */
    @AllArgsConstructor
    @Getter
    public enum SkinInvasionEnum {
        //(-) (+) (/) 未送检
        NOT_SEEN("not_seen", "(-)"),
        SEEN("seen", "(+)"),
        UNABLE_TO_EVALUATE("unable_to_evaluate", "(/)"),
        NOT_SENT("not_sent", "未送检");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(SkinInvasionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 淋巴结-名称
     */
    @AllArgsConstructor
    @Getter
    public enum LymphNodeNameEnum {
        //小弯侧LN 大弯侧LN 左侧腋窝淋巴结 右侧腋窝淋巴结 左前哨淋巴结 右前哨淋巴结 左侧锁骨下淋巴结 右侧锁骨下淋巴结 左侧胸骨旁淋巴结 右侧胸骨旁淋巴结 左侧胸肌间淋巴结 右侧胸肌间淋巴结 左侧锁骨上淋巴结 右侧锁骨上淋巴结 左侧内乳淋巴结 右侧内乳淋巴结
        SMALL_CURVED_SIDE_LN("small_curved_side_ln", "小弯侧LN"),
        LARGE_CURVED_SIDE_LN("large_curved_side_ln", "大弯侧LN"),
        LEFT_AXILLA_LN("left_axilla_ln", "左侧腋窝淋巴结"),
        RIGHT_AXILLA_LN("right_axilla_ln", "右侧腋窝淋巴结"),
        LEFT_SENTINEL_LN("left_sentinel_ln", "左前哨淋巴结"),
        RIGHT_SENTINEL_LN("right_sentinel_ln", "右前哨淋巴结"),
        LEFT_SUBCLAVIAN_LN("left_subclavian_ln", "左侧锁骨下淋巴结"),
        RIGHT_SUBCLAVIAN_LN("right_subclavian_ln", "右侧锁骨下淋巴结"),
        LEFT_STERNOCLEIDOMASTOID_LN("left_sternocleidomastoid_ln", "左侧胸骨旁淋巴结"),
        RIGHT_STERNOCLEIDOMASTOID_LN("right_sternocleidomastoid_ln", "右侧胸骨旁淋巴结"),
        LEFT_MUSCLE_INTERSTITIAL_LN("left_muscle_interstitial_ln", "左侧胸肌间淋巴结"),
        RIGHT_MUSCLE_INTERSTITIAL_LN("right_muscle_interstitial_ln", "右侧胸肌间淋巴结"),
        LEFT_SUPRACLAVIAN_LN("left_supraclavian_ln", "左侧锁骨上淋巴结"),
        RIGHT_SUPRACLAVIAN_LN("right_supraclavian_ln", "右侧锁骨上淋巴结"),
        LEFT_INTERNAL_MAMMARY_LN("left_internal_mammary_ln", "左侧内乳淋巴结"),
        RIGHT_INTERNAL_MAMMARY_LN("right_internal_mammary_ln", "右侧内乳淋巴结");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(LymphNodeNameEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 淋巴结结外侵犯（ENE）
     */
    @AllArgsConstructor
    @Getter
    public enum LymphGlandExtraluminalInvasionEnum {
        //有 无
        YES("yes", "有"),
        NO("no", "无");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(LymphGlandExtraluminalInvasionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 原发灶Miller-Payne分级
     */
    @AllArgsConstructor
    @Getter
    public enum PrimaryTumorMillerPayneGradeEnum {
        //1级（无改变，PX） 2级 （≤30%）3级 （30%-90%）4級（≥90%）5級（无浸润性癌）
        GRADE_1("grade_1", "1级（无改变，PX）"),
        GRADE_2("grade_2", "2级 （≤30%）"),
        GRADE_3("grade_3", "3级 （30%-90%）"),
        GRADE_4("grade_4", "4級（≥90%）"),
        GRADE_5("grade_5", "5級（无浸润性癌）");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(PrimaryTumorMillerPayneGradeEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * RCB分級
     */
    @AllArgsConstructor
    @Getter
    public enum RCBGradeEnum {
        //0（病理完全缓解（pCR）） I（少量肿瘤残余）II（中等量肿瘤残余) III（广泛肿瘤残余）
        R0("r0", "0（病理完全缓解（pCR））"),
        R1("r1", "I（少量肿瘤残余）"),
        R2("r2", "II（中等量肿瘤残余)"),
        R3("r3", "III（广泛肿瘤残余）");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(RCBGradeEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 肿瘤细胞密度
     */
    @AllArgsConstructor
    @Getter
    public enum TumorCellDensityEnum {
        //0 1 5 10 20 30 40 50 60 70 80 90
        P0("p0", "0"),
        P1("p1", "1"),
        P5("p5", "5"),
        P10("p10", "10"),
        P20("p20", "20"),
        P30("p30", "30"),
        P40("p40", "40"),
        P50("p50", "50"),
        P60("p60", "60"),
        P70("p70", "70"),
        P80("p80", "80"),
        P90("p90", "90");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(TumorCellDensityEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }



    /**
     * TNM分期-TNM分期
     */
    @AllArgsConstructor
    @Getter
    public enum LesionTnmStageEnum {
        //rp yp mp p
        RP("rp", "rp"),
        YP("yp", "yp"),
        MP("mp", "mp"),
        P("p", "p");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(LesionTnmStageEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 病理分期-T
     */
    @AllArgsConstructor
    @Getter
    public enum PathologicalStageTEnum {
        //Tx T0 Tis Tis(DCIS) Tis(Paget) T1mi T1a T1b T1c T2  T3 T4a T4b T4c T4d
        TX("tx", "Tx"),
        T0("t0", "T0"),
        TIS("tis", "Tis"),
        TIS_DCIS("tis_dcis", "Tis(DCIS)"),
        TIS_PAGET("tis_paget", "Tis(Paget)"),
        T1MI("t1mi", "T1mi"),
        T1A("t1a", "T1a"),
        T1B("t1b", "T1b"),
        T1C("t1c", "T1c"),
        T2("t2", "T2"),
        T3("t3", "T3"),
        T4A("t4a", "T4a"),
        T4B("t4b", "T4b"),
        T4C("t4c", "T4c"),
        T4D("t4d", "T4d");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(PathologicalStageTEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 病理分期-N
     */
    @AllArgsConstructor
    @Getter
    public enum PathologicalStageNEnum {
        //Nx N0 N0(i+) N1mi N1a N1b N1c N2a N2b N3a N3b N3c
        NX("nx", "Nx"),
        N0("n0", "N0"),
        N0_I_PLUS("n0_i_plus", "N0(i+)"),
        N1MI("n1mi", "N1mi"),
        N1A("n1a", "N1a"),
        N1B("n1b", "N1b"),
        N1C("n1c", "N1c"),
        N2A("n2a", "N2a"),
        N2B("n2b", "N2b"),
        N3A("n3a", "N3a"),
        N3B("n3b", "N3b"),
        N3C("n3c", "N3c");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(PathologicalStageNEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 病理分期-M
     */
    @AllArgsConstructor
    @Getter
    public enum PathologicalStageMEnum {
        //cM0 cM1 pM1
        CM0("cm0", "cM0"),
        CM1("cm1", "cM1"),
        PM1("pm1", "pM1");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(PathologicalStageMEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 病理分期-总分期
     */
    @AllArgsConstructor
    @Getter
    public enum PathologicalStageTotalEnum {
        //0 IA IB IIA IIB IIIA IIIB IIIC IV
        ZERO("zero", "0"),
        IA("ia", "IA"),
        IB("ib", "IB"),
        IIA("iia", "IIA"),
        IIB("iib", "IIB"),
        IIIA("iiia", "IIIA"),
        IIIB("iiib", "IIIB"),
        IIIC("iiic", "IIIC"),
        IV("iv", "IV");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(PathologicalStageTotalEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 免疫组化-分析结果
     */
    @AllArgsConstructor
    @Getter
    public enum ResultEnum {

        REDUCE("-", "-"),
        PLUS("+", "+"),
        PLUS2("++", "++"),
        PLUS3("+++", "+++"),
        PLUS_OR_MINUS("±", "±");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(ResultEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 免疫组化-其他表达
     */
    @AllArgsConstructor
    @Getter
    public enum OtherExpressionEnum {
        // 肌上皮细胞 间质免疫细胞  脉管 其他
        MYOEPITHELIUM("myoepithelium", "肌上皮细胞"),
        INTERSTITIAL_IMMUNE_CELL("interstitial_immune_cell", "间质免疫细胞"),
        VASCULAR("vascular", "脉管"),
        OTHER("other", "其他");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(OtherExpressionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 免疫组化-PDL1-分析结果
     */
    @AllArgsConstructor
    @Getter
    public enum Pdl1ResultEnum {
        // 低表达 高表达
        LOW_EXPRESSION("low_expression", "低表达"),
        HIGH_EXPRESSION("high_expression", "高表达");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(Pdl1ResultEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 其他送检组织
     */
    @AllArgsConstructor
    @Getter
    public enum OtherInspectionOrganizationsEnum {

        GASTRIC_TISSUE("gastric_tissue", "胃组织"),
        ANASTOMOTIC_SITE_NEAR_END("anastomotic_site_near_end", "吻合口近端"),
        ANASTOMOTIC_SITE_REMOTE_END("anastomotic_site_remote_end", "吻合口远端");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(OtherInspectionOrganizationsEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

}
